home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Aminet 1 (Walnut Creek)
/
Aminet - June 1993 [Walnut Creek].iso
/
usenet
/
sources
/
volume89
/
graphics
/
mandelv2.9
< prev
next >
Wrap
Internet Message Format
|
1989-06-21
|
70KB
Path: xanth!ames!oliveb!sun!swap!page
From: page%swap@Sun.COM (Bob Page)
Newsgroups: comp.sources.amiga
Subject: v89i160: mandelvroom - mandelbrot explorer v2.0, Part09/09
Message-ID: <111394@sun.Eng.Sun.COM>
Date: 21 Jun 89 04:02:33 GMT
Sender: news@sun.Eng.Sun.COM
Lines: 2596
Approved: page@sun.com
Submitted-by: kevin@uts.amdahl.com (Kevin Clague)
Posting-number: Volume 89, Issue 160
Archive-name: graphics/mandelv20.9
# This is a shell archive.
# Remove anything above and including the cut line.
# Then run the rest of the file through 'sh'.
# Unpacked files will be owned by you and have default permissions.
#----cut here-----cut here-----cut here-----cut here----#
#!/bin/sh
# shar: SHell ARchive
# Run the following text through 'sh' to create:
# safeclose.h
# saveilbm.c
# saveilbm.h
# savemand.c
# scroll.c
# showhelp.c
# standard.h
# status.c
# tasks.c
# This is archive 9 of a 9-part kit.
# This archive created: Tue Jun 20 20:45:33 1989
echo "extracting safeclose.h"
sed 's/^X//' << \SHAR_EOF > safeclose.h
X/* CloseWindowSafely()
X* This module should be used whenever you are sharing an IDCMP
X* message port with more than one window. Rather than calling CloseWindow(),
X* you should use CloseWindowSafely(). This will keep Intuition from
X* Guru Meditation, and thus is considered a good thing. You should still
X* use CloseWindow for the very last window you close.
X* The reason this is needed, is because Intuition will re-claim
X* any outstanding messages for a window when the window is closed. But...
X* it can't take them out of your message port. Thus, you will receive
X* invalid messages and bad things will happen. Very bad things.
X* This code is a slightly condensed version of the same routine
X* written by Neil Katin of Amiga for the April '86 Commodore Developers
X* Newsletter, Amiga Mail (tm).
X*/
X
X#ifndef SAFECLOSE
X
X#define SAFECLOSE
X
X
X/* CloseWindowSafely(window), window is pointer to struct Window */
X
Xextern void CloseWindowSafely();
X
X#endif
X
SHAR_EOF
echo "extracting saveilbm.c"
sed 's/^X//' << \SHAR_EOF > saveilbm.c
X/***************************************************************************
X* SaveILBM.c -- Save front screen as ILBM file
X* Saves a CAMG chunk for Amiga ViewModes
X* by Carolyn Scheppner CBM 10/86
X*
X* modified by Kevin L. Clague for use in Mandelbrot
X*
X* Using IFF rtns by J.Morrison and S.Shaw of Electronic Arts
X*
X***************************************************************************/
X
X#include "SaveILBM.h"
X
X/* CAMG Stuff */
Xtypedef struct {
X ULONG ViewModes;
X } CamgChunk;
X
X#define PutCAMG(context, camg) \
X PutCk(context, ID_CAMG, sizeof(CamgChunk), (BYTE *)camg)
X
X#define ID_CRNG MakeID('C','R','N','G')
X#define PutCRNG(context, crng) \
X PutCk(context, ID_CRNG, sizeof(CrngChunk), (BYTE *)crng)
X
X#define bufSize 512
X
Xextern struct IntuitionBase *IntuitionBase;
Xextern struct Screen *screen;
X
Xstruct Screen *frontScreen;
X
Xstruct ViewPort *picViewPort;
Xstruct BitMap *picBitMap;
XWORD *picColorTable;
XULONG picViewModes;
X
X/* ILBM Icon Image */
X
XUSHORT ILBMimagedata[] = {
X 0x0000, 0x0000, 0x0000, 0x0000,
X 0x7FFF, 0xFFFF, 0xFFFF, 0xFF80,
X 0x6000, 0x0000, 0x0000, 0x0180,
X 0x6000, 0x07FF, 0xFFFF, 0x8180,
X 0x6000, 0x401F, 0xFFC0, 0x0180,
X 0x6002, 0xE000, 0x0000, 0x0180,
X 0x6003, 0x6002, 0x0008, 0x0180,
X 0x600B, 0xF807, 0x005E, 0x0180,
X 0x6001, 0xFC03, 0x809F, 0x8180,
X 0x6000, 0x0E07, 0xC2FF, 0xE180,
X 0x600D, 0xAF05, 0xE017, 0xF980,
X 0x6021, 0x2F83, 0xC057, 0xF980,
X 0x6025, 0xFF1F, 0x24C7, 0xF980,
X 0x6097, 0xFA6E, 0x881F, 0xF980,
X 0x601E, 0xFCEC, 0x3B5B, 0xF980,
X 0x6055, 0xFFBA, 0x559F, 0xF980,
X 0x60EF, 0xFFFF, 0xFFFF, 0xF980,
X 0x6000, 0x0000, 0x0000, 0x0180,
X 0x7FFF, 0xFFFF, 0xFFFF, 0xFF80,
X 0x0000, 0x0000, 0x0000, 0x0000,
X/**/
X 0xFFFF, 0xFFFF, 0xFFFF, 0xFFC0,
X 0x8000, 0x0000, 0x0000, 0x0040,
X 0x9FFF, 0xFFFF, 0xFFFF, 0xFE40,
X 0x9800, 0x0000, 0x0000, 0x0640,
X 0x9800, 0x0000, 0x0000, 0x0640,
X 0x9801, 0x0000, 0x0000, 0x0640,
X 0x9804, 0x8004, 0x0000, 0x0640,
X 0x9804, 0x8008, 0x0020, 0x0640,
X 0x981F, 0x0C0C, 0x0160, 0x0640,
X 0x983F, 0xFE1F, 0x8D00, 0x0640,
X 0x98FF, 0xFF7F, 0xDFE8, 0x0640,
X 0x9BFF, 0xFFFF, 0xFFFF, 0x0640,
X 0x9FFF, 0xFFFF, 0xFFFF, 0x8640,
X 0x9FFF, 0xFFFF, 0xFFFF, 0xFE40,
X 0x9FFF, 0xFFFF, 0xFFFF, 0xFE40,
X 0x9FFF, 0xFFFF, 0xFFFF, 0xFE40,
X 0x9FFF, 0xFFFF, 0xFFFF, 0xFE40,
X 0x9FFF, 0xFFFF, 0xFFFF, 0xFE40,
X 0x8000, 0x0000, 0x0000, 0x0040,
X 0xFFFF, 0xFFFF, 0xFFFF, 0xFFC0
X/**/
X };
X
Xstruct Image ILBMimage[] = {
X 0, /* LeftEdge */
X 0, /* TopEdge */
X 58, /* Width */
X 20, /* Height */
X 2, /* Depth */
X (USHORT *)&ILBMimagedata, /* ImageData */
X 0x3, /* PlanePick */
X 0x0, /* PlaneOnOff */
X 0 /* [NextImage] */
X };
X
Xstruct DiskObject ILBMIcon = {
X WB_DISKMAGIC, /* do_Magic */
X WB_DISKVERSION, /* do_Version */
X
X/* Embedded Gadget Structure */
X 0, /* [NextGadget] */
X 147, /* LeftEdge */
X 23, /* TopEdge */
X 58, /* Width */
X 20, /* Height */
X 0x4, /* Flags */
X 0x3, /* Activation */
X 0x1, /* GadgetType */
X (APTR)&ILBMimage, /* GadgetRender */
X NULL, /* SelectRender */
X NULL, /* GadgetText */
X 0x0, /* MutualExclude */
X 0x0, /* [SpecialInfo] */
X 0, /* GadgetID */
X 0x0, /* [UserData] */
X
X/* Rest of DiskObject structure */
X 0x4, /* do_Type */
X ":ViewILBM", /* do_Default Tool */
X 0xC06508, /* [do_ToolTypes] */
X NO_ICON_POSITION, /* do_CurrentX */
X NO_ICON_POSITION, /* do_CurrentY */
X 0x0, /* [do_DrawerData] */
X 0x0, /* [do_ToolWindow] */
X 0x0 /* do_StackSize */
X };
X
X/**************************************************************************
X *
X * Save the current screen as an ILBM file
X *
X **************************************************************************/
X
XSaveILBM(FileName, Crng, numCrng)
X char *FileName;
X CrngChunk *Crng;
X int numCrng;
X{
X LONG file;
X IFFP iffp = NO_FILE;
X
X int l;
X
X if (!(file = Open(FileName, MODE_NEWFILE))) {
X
X char Msg[80];
X sprintf(Msg,"Can't open file %s\n",FileName);
X DispErrMsg(Msg,0);
X return(0);
X }
X
X Write(file,"x",1); /* 1.1 so Seek to beginning works ? */
X
X frontScreen = screen;
X
X picViewPort = &( frontScreen->ViewPort );
X picBitMap = (struct BitMap*)picViewPort->RasInfo->BitMap;
X picColorTable = (WORD *)picViewPort->ColorMap->ColorTable;
X picViewModes = (ULONG)picViewPort->Modes;
X
X iffp = PutPicture(file, picBitMap, picColorTable, picViewModes,
X Crng, numCrng);
X Close(file);
X
X if (iffp == IFF_OKAY && FromWB ) {
X
X /* This line outputs the icon */
X PutDiskObject(FileName,&ILBMIcon);
X }
X} /* SaveILBM */
X
X
X/** PutPicture() ***********************************************************
X *
X * Put a picture into an IFF file.
X * This procedure calls PutAnILBM, passing in an <x, y> location of <0, 0>,
X * a NULL mask, and a locally-allocated buffer. It also assumes you want to
X * write out all the bitplanes in the BitMap.
X *
X ***************************************************************************/
XPoint2D nullPoint = {0, 0};
X
XIFFP PutPicture(file, bitmap, colorMap, viewmodes, crng, numcrng)
X LONG file; struct BitMap *bitmap;
X WORD *colorMap; ULONG viewmodes;
X CrngChunk *crng;
X int numcrng;
X {
X BYTE buffer[bufSize];
X return( PutAnILBM(file, bitmap, NULL,
X colorMap, bitmap->Depth, viewmodes,
X &nullPoint, crng, numcrng, buffer, bufSize) );
X }
X
X
X/** PutAnILBM() ************************************************************
X *
X * Write an entire BitMap as a FORM ILBM in an IFF file.
X * This version works for any display mode (C. Scheppner).
X *
X * Normal return result is IFF_OKAY.
X *
X * The utility program IFFCheck would print the following outline of the
X * resulting file:
X *
X * FORM ILBM
X * BMHD
X * CAMG
X * CMAP
X * CRNG
X * CRNG
X * CRNG
X * CRNG
X * BODY (compressed)
X *
X ***************************************************************************/
X#define CkErr(expression) {if (ifferr == IFF_OKAY) ifferr = (expression);}
X
XIFFP PutAnILBM(file, bitmap, mask, colorMap, depth,
X viewmodes, xy, crng, numcrng,
X buffer, bufsize)
X LONG file;
X struct BitMap *bitmap;
X BYTE *mask; WORD *colorMap; UBYTE depth;
X ULONG viewmodes;
X Point2D *xy; BYTE *buffer; LONG bufsize;
X CrngChunk *crng;
X int numcrng;
X {
X BitMapHeader bmHdr;
X CamgChunk camgChunk;
X GroupContext fileContext, formContext;
X IFFP ifferr;
X WORD pageWidth, pageHeight;
X int i;
X
X pageWidth = (bitmap->BytesPerRow) << 3;
X pageHeight = bitmap->Rows;
X
X ifferr = InitBMHdr(&bmHdr, bitmap, mskNone,
X cmpByteRun1, 0, pageWidth, pageHeight);
X /* You could write an uncompressed image by passing cmpNone instead
X * of cmpByteRun1 to InitBMHdr. */
X bmHdr.nPlanes = depth; /* This must be <= bitmap->Depth */
X if (mask != NULL) bmHdr.masking = mskHasMask;
X bmHdr.x = xy->x; bmHdr.y = xy->y;
X
X camgChunk.ViewModes = viewmodes;
X
X CkErr( OpenWIFF(file, &fileContext, szNotYetKnown) );
X CkErr(StartWGroup(&fileContext, FORM, szNotYetKnown, ID_ILBM, &formContext));
X
X CkErr( PutBMHD(&formContext, &bmHdr) );
X CkErr( PutCAMG(&formContext, &camgChunk) );
X CkErr( PutCMAP(&formContext, colorMap, depth) );
X
X for (i = 0; i < numcrng; i++) {
X CkErr( PutCRNG(&formContext, &crng[i]));
X }
X CkErr( PutBODY(&formContext, bitmap, mask, &bmHdr, buffer, bufsize) );
X
X CkErr( EndWGroup(&formContext) );
X CkErr( CloseWGroup(&fileContext) );
X return( ifferr );
X }
X
X
SHAR_EOF
echo "extracting saveilbm.h"
sed 's/^X//' << \SHAR_EOF > saveilbm.h
X/*
X * MandelVroom 2.0
X *
X * (c) Copyright 1987,1989 Kevin L. Clague, San Jose, CA
X *
X * All rights reserved.
X *
X * Permission is hereby granted to distribute this program's source
X * executable, and documentation for non-comercial purposes, so long as the
X * copyright notices are not removed from the sources, executable or
X * documentation. This program may not be distributed for a profit without
X * the express written consent of the author Kevin L. Clague.
X *
X * This program is not in the public domain.
X *
X * Fred Fish is expressly granted permission to distribute this program's
X * source and executable as part of the "Fred Fish freely redistributable
X * Amiga software library."
X *
X * Permission is expressly granted for this program and it's source to be
X * distributed as part of the Amicus Amiga software disks, and the
X * First Amiga User Group's Hot Mix disks.
X *
X * contents: includes required by SaveILBM.c
X */
X
X#include "mandp.h"
X#include <libraries/dos.h>
X#include <graphics/rastport.h>
X#include <graphics/view.h>
SHAR_EOF
echo "extracting savemand.c"
sed 's/^X//' << \SHAR_EOF > savemand.c
X/*
X * MandelVroom 2.0
X *
X * (c) Copyright 1987,1989 Kevin L. Clague, San Jose, CA
X *
X * All rights reserved.
X *
X * Permission is hereby granted to distribute this program's source
X * executable, and documentation for non-comercial purposes, so long as the
X * copyright notices are not removed from the sources, executable or
X * documentation. This program may not be distributed for a profit without
X * the express written consent of the author Kevin L. Clague.
X *
X * This program is not in the public domain.
X *
X * Fred Fish is expressly granted permission to distribute this program's
X * source and executable as part of the "Fred Fish freely redistributable
X * Amiga software library."
X *
X * Permission is expressly granted for this program and it's source to be
X * distributed as part of the Amicus Amiga software disks, and the
X * First Amiga User Group's Hot Mix disks.
X *
X * contents: this file contains the functions to save projects to disk,
X * load projects from disk, and save icon files (if the program was started
X * from the WorkBench.)
X */
X
X#include "mandp.h"
X
Xextern struct NewScreen NewScreen;
X
Xextern ULONG CalcTime;
X
Xextern BYTE FromWB;
X
X ULONG BorderType;
X
XUSHORT MandimageData1[] = {
X 0xFFFF, 0xFFFF, 0xFFFF, 0xFFC0,
X 0xFFFF, 0xFFFF, 0xFFFF, 0xFFC0,
X 0xFFFF, 0xFFE3, 0xFFFF, 0xFFC0,
X 0xFFFF, 0xF101, 0x67FF, 0xFFC0,
X 0xFFF8, 0x7040, 0xC0F7, 0xFFC0,
X 0xF9D4, 0x4441, 0x414B, 0xFFC0,
X 0xF80F, 0x0F79, 0x8403, 0xFFC0,
X 0xDA0F, 0xFFFF, 0xEC01, 0xFFC0,
X 0x9743, 0xFFFF, 0xFE46, 0x0FC0,
X 0x8FFF, 0xFFFF, 0xFF80, 0x3FC0,
X 0xF03F, 0xFFEF, 0xFFC0, 0x7FC0,
X 0xB7FF, 0xFE00, 0x3F91, 0xDFC0,
X 0xFFFF, 0xF878, 0x3FC0, 0x07C0,
X 0x8FFF, 0xF8F0, 0x7F80, 0x17C0,
X 0xB7FF, 0xF0FF, 0xFFC0, 0x3FC0,
X 0xFFFF, 0xF83F, 0xFC03, 0x7FC0,
X 0xFFFF, 0xF70F, 0xD801, 0xFFC0,
X 0xFFFF, 0xFE00, 0x0000, 0xFFC0,
X 0xBFFF, 0xFE50, 0x415C, 0xFFC0,
X 0xBFFF, 0xFFFC, 0x90FF, 0xFFC0,
X 0xFFFF, 0xFFFD, 0xFEFF, 0xFFC0,
X 0xFFFF, 0xFFFF, 0xFFFF, 0xFFC0,
X/**/
X 0x01E0, 0xE1F0, 0xFC03, 0xFE00,
X 0x41E1, 0xC78F, 0xC03F, 0xF800,
X 0x61C7, 0x2BDD, 0xE1FF, 0x0000,
X 0x4394, 0x7FFF, 0xFD80, 0x0000,
X 0x4C57, 0xFFBF, 0x7FFD, 0xFFC0,
X 0x1FBB, 0xFFFF, 0xBFB4, 0x3FC0,
X 0x6FF0, 0xFCCF, 0xFFFC, 0xC1C0,
X 0x65F3, 0xF9C4, 0xB7FF, 0x9C00,
X 0x79FF, 0x8F33, 0x6BBD, 0xFB00,
X 0x70E7, 0xF136, 0x667F, 0xF9C0,
X 0x4FE0, 0x19D4, 0x0D3F, 0xD8C0,
X 0x4E9F, 0xC9FF, 0xC3EE, 0x3440,
X 0x6580, 0x67D7, 0xECBF, 0xFB00,
X 0x7A3E, 0x2FBF, 0x9EFF, 0xFF80,
X 0x69FF, 0xCF2A, 0xA3FF, 0xF580,
X 0x6700, 0x67E6, 0xC7FD, 0xB1C0,
X 0x583F, 0x1AF4, 0xA7FF, 0xF3C0,
X 0x31FF, 0xF5FF, 0xFFFF, 0x73C0,
X 0x53E0, 0x1DAF, 0xFEA7, 0x23C0,
X 0x4700, 0x00E7, 0xEF58, 0xE1C0,
X 0x4E07, 0xFFE3, 0x77E3, 0xC1C0,
X 0x383F, 0xFC00, 0x078F, 0x81C0,
X/**/
X };
X
Xstruct Image Mandimage1 = {
X 0, /* LeftEdge */
X 0, /* TopEdge */
X 58, /* Width */
X 22, /* Height */
X 2, /* Depth */
X (USHORT *)MandimageData1, /* ImageData */
X 0xFF, /* PlanePick */
X 0x0, /* PlaneOnOff */
X 0, /* [NextImage] */
X };
X
Xstruct DiskObject MandIcon = {
X WB_DISKMAGIC, /* do_Magic */
X WB_DISKVERSION, /* do_Version */
X
X/* Embedded Gadget Structure */
X 0, /* [NextGadget] */
X 23, /* LeftEdge */
X 14, /* TopEdge */
X 58, /* Width */
X 23, /* Height */
X 0x5, /* Flags */
X 0x3, /* Activation */
X 0x1, /* GadgetType */
X (APTR)&Mandimage1, /* GadgetRender */
X NULL, /* SelectRender */
X NULL, /* GadgetText */
X 0x0, /* MutualExclude */
X 0x0, /* [SpecialInfo] */
X 0, /* GadgetID */
X 0x0, /* [UserData] */
X
X/* Rest of DiskObject structure */
X 0x4, /* do_Type */
X "MandelBrot:MandelVroom", /* do_Default Tool */
X 0x0, /* [do_ToolTypes] */
X 0x80000000, /* do_CurrentX */
X 0x80000000, /* do_CurrentY */
X 0x0, /* [do_DrawerData] */
X 0x0, /* [do_ToolWindow] */
X 10240 /* do_StackSize */
X };
X
XUSHORT JuliaimageData1[] = {
X 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
X 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
X 0x0000, 0x0000, 0x0F80, 0x0000, 0x0000,
X 0x0000, 0x0000, 0x7F60, 0x0000, 0x0000,
X 0x0000, 0x000F, 0xF07E, 0x0000, 0x0000,
X 0x0000, 0x0079, 0xC071, 0xC000, 0x0000,
X 0x0004, 0xFFDB, 0xFFFE, 0xFC00, 0x0000,
X 0x001C, 0x6FDF, 0xFFFF, 0xFF7D, 0x0000,
X 0x00FF, 0xF183, 0xFFE0, 0x73C3, 0xC000,
X 0x05FF, 0xF100, 0x7FE0, 0xC3FF, 0xFC00,
X 0x33C3, 0xFC00, 0x7FFE, 0x007C, 0x6D80,
X 0x1F85, 0xF800, 0xFFF8, 0x007F, 0x0670,
X 0x03F1, 0xFC06, 0x3FF0, 0x01FE, 0x03E0,
X 0x003B, 0xFF98, 0x0FF0, 0x021F, 0xDF80,
X 0x000F, 0x187C, 0x3FFF, 0xE6FE, 0xB000,
X 0x0003, 0xFFFD, 0xFFFF, 0xDFC1, 0xC000,
X 0x0000, 0x003E, 0x7FDF, 0x7FFF, 0x0000,
X 0x0000, 0x0006, 0x785B, 0x6000, 0x0000,
X 0x0000, 0x0000, 0xFC7E, 0x0000, 0x0000,
X 0x0000, 0x0000, 0x1BF0, 0x0000, 0x0000,
X 0x0000, 0x0000, 0x0380, 0x0000, 0x0000,
X 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
X/**/
X 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
X 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
X 0x0000, 0x0000, 0x0D80, 0x0000, 0x0000,
X 0x0000, 0x0000, 0x70E0, 0x0000, 0x0000,
X 0x0000, 0x000F, 0xFFFE, 0x0000, 0x0000,
X 0x0000, 0x007E, 0x3F8F, 0xC000, 0x0000,
X 0x0007, 0xFFF4, 0x0001, 0xFC00, 0x0000,
X 0x001F, 0x93E0, 0x0000, 0xFFF3, 0x0000,
X 0x00F0, 0x0FFC, 0x001F, 0xFC3D, 0xC000,
X 0x0660, 0x0FFF, 0x801F, 0xFC00, 0x7C00,
X 0x2C7C, 0x1FFF, 0x9FFF, 0xFF83, 0xF380,
X 0x1C7E, 0x07FF, 0xFFFF, 0xFF83, 0xF990,
X 0x03FE, 0x03FF, 0xFF8F, 0xFFC1, 0xFC60,
X 0x003C, 0x007F, 0xF00F, 0xFFE0, 0x3F80,
X 0x000F, 0xE7FB, 0xC000, 0x1F03, 0x7000,
X 0x0002, 0xFFFE, 0x0000, 0x3FFE, 0xC000,
X 0x0000, 0x003F, 0x80A1, 0xFFFF, 0x0000,
X 0x0000, 0x0007, 0xC7E6, 0xE000, 0x0000,
X 0x0000, 0x0000, 0xFFBE, 0x0000, 0x0000,
X 0x0000, 0x0000, 0x1C70, 0x0000, 0x0000,
X 0x0000, 0x0000, 0x0280, 0x0000, 0x0000,
X 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
X/**/
X };
X
Xstruct Image Juliaimage1 = {
X 0, /* LeftEdge */
X 0, /* TopEdge */
X 78, /* Width */
X 22, /* Height */
X 2, /* Depth */
X (USHORT *)JuliaimageData1, /* ImageData */
X 0xFF, /* PlanePick */
X 0x0, /* PlaneOnOff */
X 0, /* [NextImage] */
X };
X
Xstruct DiskObject JuliaIcon = {
X WB_DISKMAGIC, /* do_Magic */
X WB_DISKVERSION, /* do_Version */
X
X/* Embedded Gadget Structure */
X 0, /* [NextGadget] */
X 23, /* LeftEdge */
X 14, /* TopEdge */
X 78, /* Width */
X 23, /* Height */
X 0x5, /* Flags */
X 0x3, /* Activation */
X 0x1, /* GadgetType */
X (APTR)&Juliaimage1, /* GadgetRender */
X NULL, /* SelectRender */
X NULL, /* GadgetText */
X 0x0, /* MutualExclude */
X 0x0, /* [SpecialInfo] */
X 0, /* GadgetID */
X 0x0, /* [UserData] */
X
X/* Rest of DiskObject structure */
X 0x4, /* do_Type */
X "MandelBrot:MandelVroom", /* do_Default Tool */
X 0x0, /* [do_ToolTypes] */
X 0x80000000, /* do_CurrentX */
X 0x80000000, /* do_CurrentY */
X 0x0, /* [do_DrawerData] */
X 0x0, /* [do_ToolWindow] */
X 10240 /* do_StackSize */
X };
X
X/*
X * Save all the data needed to restore the system to current state.
X */
Xint
XSaveCounts(SaveName, Pict)
X register char *SaveName;
X register struct Picture *Pict;
X{
X register FILE *SaveFile;
X
X USHORT ViewModes;
X UBYTE Depth;
X ULONG Version = VERSION;
X char ErrMsg[80];
X
X /*
X * Change the mouse pointer to Sleepy pointer
X */
X SetSleepyPointer();
X
X /*
X * open the desired file for writing
X */
X SaveFile = fopen(SaveName,"w");
X
X if (SaveFile == (FILE *) NULL) {
X sprintf(ErrMsg, "Can't open file %s", SaveName);
X DispErrMsg(ErrMsg, 0);
X return(UNSUCCESSFUL);
X }
X
X Pict->LeftEdge = Pict->Window->LeftEdge;
X Pict->TopEdge = Pict->Window->TopEdge;
X
X /*
X * if there is data to save, save it
X */
X if (Pict->Counts && ! (Pict->Flags & NO_RAM_GENERATE) ) {
X
X if (Pict->pNode.ln_Type == MANDPICT) {
X
X /*
X * Put out the file header
X */
X fwrite((char *) "MAN4", 4, 1, SaveFile);
X } else {
X
X /*
X * Put out the file header
X */
X fwrite((char *) "JUL4", 4, 1, SaveFile);
X }
X
X /*
X * Put out the revision number
X */
X fwrite((char *) Version, sizeof(Version), 1, SaveFile);
X
X if (Pict->pNode.ln_Type == JULIAPICT) {
X
X /*
X * Put out the Julia point
X */
X fwrite((char *) &Pict->Real, sizeof(double), 1, SaveFile);
X fwrite((char *) &Pict->Imag, sizeof(double), 1, SaveFile);
X }
X
X /*
X * Put out the location on the complex plane
X */
X fwrite((char *) &Pict->RealLow, sizeof(double), 1, SaveFile);
X fwrite((char *) &Pict->ImagLow, sizeof(double), 1, SaveFile);
X fwrite((char *) &Pict->RealHigh, sizeof(double), 1, SaveFile);
X fwrite((char *) &Pict->ImagHigh, sizeof(double), 1, SaveFile);
X
X /*
X * Put out the Maximum iteration count for a given point
X */
X fwrite((char *) &Pict->MaxIteration, sizeof(SHORT), 1, SaveFile);
X
X /*
X * Put out the generator type
X */
X fwrite((char *) &Pict->MathMode, sizeof(Pict->MathMode), 1, SaveFile);
X
X /*
X * Put out the time it took to generate
X */
X fwrite((char *) &CalcTime, sizeof(CalcTime), 1, SaveFile);
X
X /*
X * Put out the screen's viewmodes
X */
X ViewModes = NewScreen.ViewModes;
X fwrite((char *) &ViewModes, sizeof(ViewModes), 1, SaveFile);
X
X /*
X * Put out the number of bit planes
X */
X Depth = NewScreen.Depth;
X fwrite((char *) &Depth, sizeof(Depth), 1, SaveFile);
X
X /*
X * Put some window flags
X */
X fwrite((char *) &BorderType, sizeof(BorderType), 1, SaveFile);
X
X /*
X * Save the Color Palette
X */
X fwrite((char *) &Pict->RGBs, sizeof(Pict->RGBs), 1, SaveFile);
X
X /*
X * Save the number of contours
X */
X fwrite((char *) &NumContours, sizeof(NumContours), 1, SaveFile);
X
X /*
X * Save the contour's heights
X */
X fwrite((char *) Pict->Heights, sizeof(SHORT), (int) NumContours, SaveFile);
X
X /*
X * Save the contour's pen numbers (Color is a misnomer)
X */
X fwrite((char *) Pict->Pens, sizeof(UBYTE), (int) NumContours, SaveFile);
X
X /*
X * Put out the image dimensions
X */
X fwrite((char *) &Pict->CountX, sizeof(SHORT), 1, SaveFile);
X fwrite((char *) &Pict->CountY, sizeof(SHORT), 1, SaveFile);
X
X /*
X * Put out project's position
X */
X fwrite((char *) &Pict->LeftEdge, sizeof(Pict->LeftEdge), 1, SaveFile);
X fwrite((char *) &Pict->TopEdge, sizeof(Pict->TopEdge), 1, SaveFile);
X fwrite((char *) &Pict->CurLine, sizeof(Pict->CurLine), 1, SaveFile);
X
X (void) WriteRLLTwo( SaveFile, Pict );
X
X } else {
X DispErrMsg("No Picture to save",0);
X fclose(SaveFile);
X return(UNSUCCESSFUL);
X }
X
X fclose(SaveFile);
X
X if (FromWB) {
X
X FILE *IconFile;
X char IconName[80];
X
X strcpy( IconName, SaveName );
X strcat( IconName, ".info" );
X
X if ((IconFile = fopen( IconName, "r" )) == NULL) {
X
X /*
X * OutPut an icon for the saved picture
X */
X if (Pict->pNode.ln_Type == MANDPICT)
X (void) PutDiskObject(SaveName,&MandIcon);
X else
X (void) PutDiskObject(SaveName,&JuliaIcon);
X
X } else {
X fclose( IconFile );
X }
X }
X
X return(SUCCESSFUL);
X} /* SaveCounts */
X
Xint
XWriteRLLTwo( SaveFile, Pict )
X register FILE *SaveFile;
X register struct Picture *Pict;
X{
X
X LONG Words;
X
X Words = Compress( Pict );
X
X fwrite( (char *) &Words, sizeof(LONG), 1, SaveFile);
X
X /* in case I ever recompile into 16 bit ints */
X
X if (sizeof(int) == 2 && sizeof(int)*Words > 65535) {
X DispErrMsg("Programming error in Savemand\n", 0);
X return(UNSUCCESSFUL);
X }
X
X fwrite( (char *) Pict->Counts, (int) (sizeof(SHORT) * Words), 1, SaveFile);
X
X Decompress( Words, Pict );
X return( SUCCESSFUL );
X}
X
X/* Compress the data. Count up how many words in a row have the same value.
X * If the count is only one, then just put the data in the compressed array.
X * Otherwise, turn on the most significant bit in the Count, and put it
X * in the compressed array, then put the potential in the array.
X *
X * Advantages:
X * - Compressed data guaranteed to be as small or smaller than uncompressed
X * data.
X * - Compression can be done in place in memory, so it is fast without
X * requiring extra memory.
X * - Once compressed, the data can be written to disk with one fwrite,
X * therefore it should be quicker than previously used method that
X * compressed and wrote to disk at the same time.
X * - Maximum iteration count for Mandelbrot potential is 32767. The
X * previous method only allowed 1023.
X */
Xint
XCompress( Pict )
X register struct Picture *Pict;
X{
X register SHORT *CountPtr,*CompressPtr;
X register SHORT Count;
X register USHORT Cur;
X register ULONG i;
X register ULONG Word = 0;
X
X i = Pict->CountsSize/sizeof(SHORT);
X
X CountPtr = CompressPtr = Pict->Counts;
X Cur = *CountPtr;
X Count = 1;
X
X while (--i) {
X CountPtr++;
X
X /*
X * Count up how many in a row have same height
X */
X if (Cur == *CountPtr) {
X Count++;
X } else {
X if ( Count > 1 ) {
X *CompressPtr++ = Count | 0x8000;
X }
X *CompressPtr++ = Cur;
X Count = 1;
X Cur = *CountPtr;
X }
X }
X
X if ( Count > 1 ) {
X *CompressPtr++ = Count | 0x8000;
X }
X *CompressPtr++ = Cur;
X
X Word = CompressPtr - Pict->Counts;
X
X return( Word );
X}
X
X/*
X * Load the state of the program from file
X */
Xint
XLoadCounts(LoadName, Pict )
X register char *LoadName;
X register struct Picture *Pict;
X{
X register FILE *LoadFile;
X USHORT ViewModes;
X UBYTE Depth;
X char Header[5];
X ULONG Version;
X char ErrMsg[80];
X int rc;
X char *File, *ExtractName();
X
X extern int Num_vp_Colors;
X extern USHORT NewViewModes;
X extern UBYTE NewDepth;
X
X extern struct MathTransBase *MathTransBase;
X extern LONG SPTIEEE;
X
X /*
X * Change the mouse pointer to Sleepy pointer
X */
X
X SetSleepyPointer();
X
X LoadFile = fopen(LoadName,"r");
X
X Pict->GenState = FINISHEDSTATE;
X
X if (LoadFile == (FILE *) NULL) {
X
X /*
X * can't read a non-existant file
X */
X sprintf(ErrMsg, "File %s not found", LoadName);
X DispErrMsg(ErrMsg, 0);
X return( UNSUCCESSFUL );
X }
X
X /*
X * Read and check the file header
X */
X (void) fread((char *) &Header[0], 4, 1, LoadFile);
X Header[4] = '\0';
X
X if (strcmp(&Header[0], "MAND") != 0 &&
X strcmp(&Header[0], "MAN1") != 0 &&
X strcmp(&Header[0], "MAN2") != 0 &&
X strcmp(&Header[0], "MAN3") != 0 &&
X strcmp(&Header[0], "MAN4") != 0 &&
X strcmp(&Header[0], "JUL3") != 0 &&
X strcmp(&Header[0], "JUL4") != 0 ) {
X
X /*
X * File of improper format
X */
X sprintf(ErrMsg, "File %s is not a MAND file",LoadName);
X DispErrMsg(ErrMsg, 0);
X fclose(LoadFile);
X return( UNSUCCESSFUL );
X }
X
X /*
X * Read in the version
X */
X (void) fread((char *) &Version, sizeof(Version), 1, LoadFile);
X
X if ( strcmp( &Header[0], "MAN2") == 0 ||
X strcmp( &Header[0], "MAN3") == 0 ||
X strcmp( &Header[0], "MAN4") == 0 ||
X strcmp( &Header[0], "JUL3") == 0 ||
X strcmp( &Header[0], "JUL4") == 0 ) {
X
X if ( strcmp( &Header[0], "JUL3") == 0 ||
X strcmp( &Header[0], "JUL4") == 0 ) {
X
X Pict->pNode.ln_Type = JULIAPICT;
X (void) fread((char *) &Pict->Real, sizeof(double), 1, LoadFile);
X (void) fread((char *) &Pict->Imag, sizeof(double), 1, LoadFile);
X } else {
X Pict->pNode.ln_Type = MANDPICT;
X }
X
X /*
X * Read in the location in the complex plane
X */
X (void) fread((char *) &Pict->RealLow, sizeof(double), 1, LoadFile);
X (void) fread((char *) &Pict->ImagLow, sizeof(double), 1, LoadFile);
X (void) fread((char *) &Pict->RealHigh, sizeof(double), 1, LoadFile);
X (void) fread((char *) &Pict->ImagHigh, sizeof(double), 1, LoadFile);
X } else {
X
X /* Must be old FFP code */
X
X LONG startx, starty, endx, endy;
X
X LONG SPTieee();
X
X /*
X * Read in the FFP form of location in the complex plane
X */
X (void) fread((char *) &startx, sizeof(LONG), 1, LoadFile);
X (void) fread((char *) &starty, sizeof(LONG), 1, LoadFile);
X (void) fread((char *) &endx, sizeof(LONG), 1, LoadFile);
X (void) fread((char *) &endy, sizeof(LONG), 1, LoadFile);
X
X /*
X * Convert it to IEEE format
X */
X if (OpenFFPLibs() != 0)
X return(UNSUCCESSFUL);
X
X startx = SPTieee( startx );
X starty = SPTieee( starty );
X endx = SPTieee( endx );
X endy = SPTieee( endy );
X
X /*
X * promote them to doubles
X */
X Pict->RealLow = (double) *( (float *) &startx );
X Pict->ImagLow = (double) *( (float *) &starty );
X Pict->RealHigh = (double) *( (float *) &endx );
X Pict->ImagHigh = (double) *( (float *) &endy );
X }
X
X /*
X * Read in the maximum iteration count for a given point
X */
X (void) fread((char *) &Pict->MaxIteration, sizeof(SHORT), 1, LoadFile);
X
X /*
X * Read in the generator type
X */
X (void) fread((char *) &Pict->MathMode, sizeof(Pict->MathMode), 1, LoadFile);
X
X /*
X * Read in the calculation time
X */
X (void) fread((char *) &CalcTime, sizeof(CalcTime), 1, LoadFile);
X
X /*
X * Read in the screen's viewmodes
X */
X (void) fread((char *) &ViewModes, sizeof(ViewModes), 1, LoadFile);
X
X ViewModes &= HIRES | INTERLACE | EXTRA_HALFBRITE;
X Pict->ViewModes = ViewModes;
X
X /*
X * Read in the number of bit planes
X */
X (void) fread((char *) &Depth, sizeof(Depth), 1, LoadFile);
X Pict->Depth = Depth;
X
X /*
X * Read in the window flags
X */
X (void) fread((char *) &BorderType, sizeof(BorderType), 1, LoadFile);
X
X /*
X * Read in the color palette information
X */
X (void) fread((char *) &Pict->RGBs[0], sizeof(Pict->RGBs), 1, LoadFile);
X
X /*
X * Read in the number of contours
X */
X (void) fread((char *) &NumContours, sizeof(NumContours), 1, LoadFile);
X
X /*
X * Read in the heights
X */
X (void) fread((char *) Pict->Heights, sizeof(SHORT), NumContours, LoadFile);
X
X /*
X * Read in the pen numbers (Color is a misnomer)
X */
X (void) fread((char *) Pict->Pens, sizeof(UBYTE), NumContours, LoadFile);
X
X for ( ; NumContours < NUMCONTS; NumContours++ ) {
X *(Pict->Heights + NumContours) = 0;
X *(Pict->Pens + NumContours) = 0;
X }
X
X /*
X * Read in the image dimensions
X */
X (void) fread((char *) &Pict->CountX, sizeof(SHORT), 1, LoadFile);
X (void) fread((char *) &Pict->CountY, sizeof(SHORT), 1, LoadFile);
X
X if ( strcmp( &Header[0], "MAN4") == 0 ||
X strcmp( &Header[0], "JUL4") == 0 ) {
X
X /*
X * Read in the image dimensions
X */
X (void) fread((char *) &Pict->LeftEdge, sizeof(Pict->LeftEdge),
X 1, LoadFile);
X (void) fread((char *) &Pict->TopEdge, sizeof(Pict->TopEdge),
X 1, LoadFile);
X (void) fread((char *) &Pict->CurLine, sizeof(Pict->CurLine),
X 1, LoadFile);
X if (Pict->CurLine > Pict->CountY)
X Pict->CurLine -= TOPMARG;
X
X } else {
X Pict->CurLine = Pict->CountY;
X }
X
X GetCountsMemory( Pict );
X
X if (Pict->Counts == (SHORT *) NULL || (Pict->Flags & NO_RAM_GENERATE)) {
X DispErrMsg("Can't load counts. Out of RAM!!",0);
X fclose(LoadFile);
X return( UNSUCCESSFUL );
X }
X
X if ( strcmp( &Header[0], "MAN3") == 0 ||
X strcmp( &Header[0], "MAN4") == 0 ||
X strcmp( &Header[0], "JUL3") == 0 ||
X strcmp( &Header[0], "JUL4") == 0 ) {
X
X rc = ReadRLLTwo( LoadFile, Pict );
X } else {
X rc = ReadRLLOne( LoadFile, Pict );
X }
X fclose(LoadFile);
X
X if (rc != SUCCESSFUL) {
X return( rc );
X }
X
X File = ExtractName( LoadName );
X strncpy( Pict->Title, " ", 2);
X strncat( Pict->Title, File, sizeof(Pict->Title)-3);
X
X CalculateGaps( Pict );
X
X NewViewModes = Pict->ViewModes;
X NewDepth = Pict->Depth;
X
X if ( MaybeNewScreen() == 0 ) {
X
X /*
X * Let's show it to them
X */
X if (OpenPicture( Pict ) != 0) {
X
X return( UNSUCCESSFUL );
X
X } else {
X LoadRGB4( vp, Pict->RGBs, Num_vp_Colors );
X ReColor( Pict );
X }
X }
X
X GetCurPict();
X
X if (CurPict) {
X LoadRGB4( vp, CurPict->RGBs, Num_vp_Colors );
X }
X InitBorderSubs();
X
X return( SUCCESSFUL );
X} /* LoadCounts */
X
X/* Load count information in pseudo RLL format */
X/* Bits 9-0 are iteration count. */
X/* Bits 15-10 are how many iteration count of same height in a row */
X
Xint
XReadRLLOne( LoadFile, Pict )
X register FILE *LoadFile;
X register struct Picture *Pict;
X{
X register SHORT *CountPtr;
X register LONG i;
X register ULONG Count = 0;
X
X USHORT t;
X
X CountPtr = Pict->Counts;
X
X i = Pict->CountsSize / sizeof( SHORT );
X
X while (i > 0) {
X if ( fread((char *) &t, sizeof(t), 1, LoadFile) == 0) {
X DispErrMsg("Premature EOF on source file",0);
X fclose(LoadFile);
X return( UNSUCCESSFUL);
X }
X Count = t >> 10;
X t = t & 0x3ff;
X
X for (; Count > 0; Count--) {
X *(CountPtr++) = t;
X i--;
X }
X }
X return( SUCCESSFUL );
X}
X
Xint
XReadRLLTwo( LoadFile, Pict )
X register FILE *LoadFile;
X register struct Picture *Pict;
X{
X LONG Words;
X
X if (fread((char *) &Words, sizeof(Words), 1, LoadFile) == 0) {
X DispErrMsg("Premature EOF on source file",0);
X fclose(LoadFile);
X return(UNSUCCESSFUL);
X }
X if (fread((char *) Pict->Counts,(int)(sizeof(SHORT)*Words),1,LoadFile) == 0){
X DispErrMsg("Premature EOF on source file",0);
X fclose(LoadFile);
X return(UNSUCCESSFUL);
X }
X Decompress( Words, Pict );
X return( SUCCESSFUL );
X}
X
X/* This algorithm decompresses the data. The data array has
X * been malloced large enough to hold the decompressed data. The data
X * is read from the disk into the array in compressed format. This
X * decompresses the data in place. The data must be decompressed from the
X * back to the front.
X */
XDecompress( Word, Pict )
X LONG Word;
X struct Picture *Pict;
X{
X register SHORT *CountPtr, *CompressPtr;
X register SHORT Count,Cur;
X register LONG i;
X register SHORT j;
X
X /* Point to the last word of compressed data */
X
X CompressPtr = Pict->Counts + Word - 1;
X
X i = Pict->CountsSize/sizeof(SHORT);
X
X /* Point to the last word of uncompressed data */
X
X CountPtr = Pict->Counts + i - 1;
X
X /* While there is data to uncompress.... */
X
X while (i > 1 && CountPtr >= Pict->Counts && CompressPtr >= Pict->Counts) {
X
X /* Pick up the last two words */
X
X Cur = *CompressPtr--;
X Count = *CompressPtr;
X
X if (Count & 0x8000) { /* is it compressed? */
X
X Count &= 0x7fff; /* extract count */
X
X for ( j = 0; j < Count; j++) { /* Decompress it */
X *CountPtr-- = Cur;
X i--;
X }
X CompressPtr--;
X
X } else {
X
X *CountPtr-- = Cur; /* just move it */
X i--;
X }
X }
X}
SHAR_EOF
echo "extracting scroll.c"
sed 's/^X//' << \SHAR_EOF > scroll.c
X/*
X * MandelVroom 2.0
X *
X * (c) Copyright 1987,1989 Kevin L. Clague, San Jose, CA
X *
X * All rights reserved.
X *
X * Permission is hereby granted to distribute this program's source
X * executable, and documentation for non-comercial purposes, so long as the
X * copyright notices are not removed from the sources, executable or
X * documentation. This program may not be distributed for a profit without
X * the express written consent of the author Kevin L. Clague.
X *
X * This program is not in the public domain.
X *
X * Fred Fish is expressly granted permission to distribute this program's
X * source and executable as part of the "Fred Fish freely redistributable
X * Amiga software library."
X *
X * Permission is expressly granted for this program and it's source to be
X * distributed as part of the Amicus Amiga software disks, and the
X * First Amiga User Group's Hot Mix disks.
X *
X * contents: this file contains the functions used to implement MandelVroom's
X * pan command. It seems to have a bug when resizing pictures slightly
X * smaller.
X */
X
X#include "mandp.h"
X
Xstatic int ScrollHotX, ScrollHotY;
X
XUBYTE ScrollOn = 1;
X
X#ifdef TEMPWINDOW
X#define SAFEBLIT
X
Xstatic struct NewWindow NewTemp = {
X 0,12, /* start position */
X 80,80, /* width, height */
X (UBYTE) 0, (UBYTE) NORMALPEN,
X MOUSEBUTTONS, /* IDCMP flags */
X /* MandWind flags */
X WINDOWDRAG | NOCAREREFRESH | SMART_REFRESH,
X (struct Gadget *) NULL, /* first gadget */
X (struct Image *) NULL, /* user checkmark */
X (UBYTE *) NULL, /* Title */
X (struct Screen *) NULL, /* pointer to screen */
X (struct BitMap *) NULL, /* pointer to superbitmap */
X 20,20,-1,-1, /* sizing */
X CUSTOMSCREEN /* type of screen */
X };
X
Xstatic struct Window *TempWind;
X#endif
X
XScrollPictCmd(Msg)
X struct IntuiMessage *Msg;
X{
X struct Window *Window;
X static struct Picture *Pict;
X
X Window = Msg->IDCMPWindow;
X Pict = (struct Picture *) Window->UserData;
X
X switch( Msg->Class ) {
X case NEWSIZE:
X if (CurPict && (CurPict->Flags & SCROLL_HAPPENED)) {
X MoveClipImage(CurPict);
X }
X break;
X
X case MENUPICK:
X switch( SUBNUM(Msg->Code) ) {
X case SETSCROLL:
X State = SCROLLPICTSTATE;
X ThrowTask(CurPict);
X if ( ! (CurPict->Flags & SCROLL_HAPPENED)) {
X
X if ( AllocScrollTemp(CurPict) == UNSUCCESSFUL ) {
X return;
X }
X SaveInitialImage(CurPict);
X }
X CurPict->Flags |= SCROLL_HAPPENED;
X SetToPointer();
X break;
X
X case GENSCROLL:
X if (CurPict && CurPict->Flags & SCROLL_HAPPENED) {
X Generate(CurPict);
X }
X break;
X
X case CANCELSCROLL:
X ReColor(CurPict);
X break;
X }
X break;
X
X case MOUSEBUTTONS:
X switch( Msg->Code ) {
X
X case SELECTDOWN: /* start drag */
X if (Pict == NULL || Pict != CurPict) {
X return;
X }
X ScrollHotX = MouseX - CurPict->ImageLoc.Left;
X ScrollHotY = MouseY - CurPict->ImageLoc.Top;
X Scroll( CurPict);
X ModifyIDCMP(Window, Window->IDCMPFlags | MOUSEMOVE);
X break;
X
X case SELECTUP: /* stop slide */
X ModifyIDCMP(Window, Window->IDCMPFlags & ~MOUSEMOVE);
X break;
X }
X break;
X
X case MOUSEMOVE:
X Scroll( CurPict);
X break;
X }
X}
X
XSaveInitialImage(Pict)
X struct Picture *Pict;
X{
X#ifdef SAFEBLIT
X SafeClipBlit(Pict->Window, Pict->LeftMarg, Pict->TopMarg,
X TempWind, 0, 0,
X Pict->CountX, Pict->CountY,
X 0xc0, __LINE__);
X#else
X ClipBlit(Pict->Window->RPort, Pict->LeftMarg, Pict->TopMarg,
X &Pict->ScrollRp, 0, 0,
X Pict->CountX, Pict->CountY,
X 0xc0);
X#endif
X}
X
XScroll( Pict )
X struct Picture *Pict;
X{
X CalcNewLoc(Pict,MouseX,MouseY); /* figure out location of new image */
X MoveClipImage(Pict);
X}
X
XCalcNewLoc(Pict, MouseX, MouseY)
X register struct Picture *Pict;
X int MouseX, MouseY;
X{
X /* set new ImageLoc */
X
X Pict->ImageLoc.Top = MouseY - ScrollHotY;
X Pict->ImageLoc.Left = MouseX - ScrollHotX;
X Pict->ImageLoc.Bot = Pict->ImageLoc.Top + Pict->CountY;
X Pict->ImageLoc.Right = Pict->ImageLoc.Left + Pict->CountX;
X}
X
XMoveClipImage(Pict)
X register struct Picture *Pict;
X{
X struct Window *Window;
X struct RastPort *wind_Rp, *tmp_Rp;
X
X register int POLeft, PORight, POTop, POBot;
X
X struct Rect SaveRect;
X struct Rect DispRect;
X
X Window = Pict->Window;
X
X SaveRect = Pict->ClipImage; /* struct assign */
X
X DispRect.Left = Pict->LeftMarg;
X DispRect.Top = Pict->TopMarg;
X DispRect.Right = Window->Width - Pict->RightMarg - 1;
X DispRect.Bot = Window->Height - Pict->BotMarg - 1;
X
X if (Pict->ImageLoc.Left > DispRect.Right ||
X Pict->ImageLoc.Top > DispRect.Bot ||
X Pict->ImageLoc.Right < DispRect.Left ||
X Pict->ImageLoc.Bot < DispRect.Top ) {
X
X return;
X }
X
X if (Pict->ImageLoc.Left < DispRect.Left) {
X Pict->ClipImage.Left = DispRect.Left;
X POLeft = -Pict->ImageLoc.Left + Pict->LeftMarg;
X } else {
X Pict->ClipImage.Left = Pict->ImageLoc.Left;
X POLeft = 0;
X }
X
X if (Pict->ImageLoc.Top < DispRect.Top) {
X Pict->ClipImage.Top = DispRect.Top;
X POTop = -Pict->ImageLoc.Top + Pict->TopMarg;
X } else {
X Pict->ClipImage.Top = Pict->ImageLoc.Top;
X POTop = 0;
X }
X
X if (Pict->ImageLoc.Right <= DispRect.Right) {
X Pict->ClipImage.Right = Pict->ImageLoc.Right;
X PORight = Pict->CountX-1;
X } else {
X Pict->ClipImage.Right = DispRect.Right;
X PORight = DispRect.Right - Pict->ImageLoc.Left;
X }
X
X if (Pict->ImageLoc.Bot <= DispRect.Bot) {
X Pict->ClipImage.Bot = Pict->ImageLoc.Bot;
X POBot = Pict->CountY - 1;
X } else {
X Pict->ClipImage.Bot = DispRect.Bot;
X POBot = DispRect.Bot - Pict->ImageLoc.Top;
X }
X
X wind_Rp = Window->RPort;
X
X#ifdef TEMPWINDOW
X tmp_Rp = TempWind->RPort;
X#else
X tmp_Rp = &Pict->ScrollRp;
X#endif
X
X if (POLeft < PORight && POTop < POBot) {
X
X /* Now copy temp rastport data to window */
X
X#ifdef SAFEBLIT
X SafeClipBlit(TempWind, POLeft, POTop, Window,
X Pict->ClipImage.Left, Pict->ClipImage.Top,
X PORight - POLeft + 1, POBot - POTop + 1, 0xc0,
X __LINE__);
X#else
X ClipBlit(tmp_Rp, POLeft, POTop, wind_Rp,
X Pict->ClipImage.Left, Pict->ClipImage.Top,
X PORight - POLeft + 1, POBot - POTop + 1, 0xc0);
X#endif
X
X#if 0
X printf("l %d t %d r %d b %d\n",POLeft, POTop, PORight, POBot);
X printf("width %d height %d\n",
X PORight - POLeft + 1, POBot - POTop + 1);
X#endif
X }
X
X Pict->DataClip.Left = POLeft;
X Pict->DataClip.Right = PORight;
X Pict->DataClip.Top = POTop;
X Pict->DataClip.Bot = POBot;
X
X /* Undraw the old picture */
X
X SetAPen(wind_Rp, 0);
X
X if (Pict->ClipImage.Left > SaveRect.Left) {
X
X FillCheck(Window, SaveRect.Left, SaveRect.Top,
X Pict->ClipImage.Left, SaveRect.Bot);
X } else
X if (Pict->ClipImage.Right < SaveRect.Right) {
X
X FillCheck(Window, Pict->ClipImage.Right, Pict->ClipImage.Top,
X SaveRect.Right, SaveRect.Bot);
X }
X
X if (Pict->ClipImage.Top > SaveRect.Top) {
X
X FillCheck(Window, SaveRect.Left, SaveRect.Top,
X SaveRect.Right, Pict->ClipImage.Top);
X } else
X if (Pict->ClipImage.Bot < SaveRect.Bot) {
X
X FillCheck(Window, SaveRect.Left, Pict->ClipImage.Bot,
X SaveRect.Right, SaveRect.Bot);
X }
X}
X
XFillCheck(Window,src_x,src_y,dst_x,dst_y)
X struct Window *Window;
X int src_x,src_y,dst_x,dst_y;
X{
X if (src_x < 0 || src_x > Window->Width) {
X#ifdef DEBUG
X printf("Bad Fill src_x %d Width %d\n",
X src_x,Window->Width);
X#endif
X return;
X }
X
X if (src_y < 0 || src_y > Window->Height) {
X#ifdef DEBUG
X printf("Bad Fill src_y %d Height %d\n",
X src_y,Window->Height);
X#endif
X return;
X }
X
X if (dst_x < 0 || dst_x > Window->Width) {
X#ifdef DEBUG
X printf("Bad Fill dst_x %d Width %d\n",
X dst_x,Window->Width);
X#endif
X return;
X }
X
X if (dst_y < 0 || dst_y > Window->Height) {
X#ifdef DEBUG
X printf("Bad Fill dst_y %d Height %d\n",
X dst_y,Window->Height);
X#endif
X return;
X }
X if (src_x > dst_x) {
X#ifdef DEBUG
X printf("inverted rect fill\n");
X#endif
X return;
X }
X if (src_y > dst_y) {
X#ifdef DEBUG
X printf("end for end flipped rect fill\n");
X#endif
X return;
X }
X RectFill(Window->RPort, src_x,src_y,dst_x,dst_y);
X}
X
XAllocScrollTemp( Pict )
X register struct Picture *Pict;
X{
X LONG Plane;
X PLANEPTR t;
X
X extern struct MenuItem ScrollSub[];
X
X static ScrollInited;
X
X extern struct NewScreen NewScreen;
X
X if ( !ScrollOn )
X return;
X
X#ifdef TEMPWINDOW
X
X NewTemp.Width = Pict->Window->Width;
X NewTemp.Height = Pict->Window->Height;
X NewTemp.LeftEdge = NewScreen.Width - NewTemp.Width-2;
X NewTemp.TopEdge = 0;
X NewTemp.Screen = screen;
X TempWind = OpenWindow( &NewTemp );
X/*WindowToBack( TempWind );*/
X return( SUCCESSFUL );
X
X#else
X
X if ( Pict->ScrollRp.BitMap == NULL ) {
X
X InitRastPort( &Pict->ScrollRp );
X Pict->ScrollRp.BitMap = &Pict->ScrollBitMap;
X }
X
X InitBitMap( &Pict->ScrollBitMap, (long) NewScreen.Depth,
X Pict->CountX, Pict->CountY);
X
X for (Plane = 0; Plane < NewScreen.Depth; Plane++) {
X
X t = (PLANEPTR) AllocRaster(Pict->CountX, Pict->CountY);
X Pict->ScrollBitMap.Planes[Plane] = (PLANEPTR) t;
X
X if (t == NULL) {
X FreeScrollTemp( Pict );
X return(UNSUCCESSFUL);
X }
X }
X return(SUCCESSFUL);
X#endif
X}
X
XFreeScrollTemp( Pict )
X struct Picture *Pict;
X{
X LONG Plane;
X
X if (Pict->Flags & SCROLL_HAPPENED) {
X
X#ifdef TEMPWINDOW
X CloseWindow( TempWind );
X#else
X
X for (Plane = 0; Plane < Pict->ScrollBitMap.Depth; Plane++) {
X
X if (Pict->ScrollBitMap.Planes[Plane]) {
X
X FreeRaster( (char *) Pict->ScrollBitMap.Planes[Plane],
X Pict->CountX,Pict->CountY);
X Pict->ScrollBitMap.Planes[Plane] = NULL;
X }
X }
X#endif
X }
X ResetScrollRects(Pict);
X}
X
XResetScrollRects(Pict)
X struct Picture *Pict;
X{
X Pict->Flags &= ~SCROLL_HAPPENED;
X
X Pict->ImageLoc.Left = Pict->LeftMarg;
X Pict->ImageLoc.Top = Pict->TopMarg;
X Pict->ImageLoc.Right = Pict->LeftMarg + Pict->CountX - 1;
X Pict->ImageLoc.Bot = Pict->TopMarg + Pict->CountY - 1;
X
X Pict->ClipImage = Pict->ImageLoc; /* struct assignment */
X}
X
X#ifdef SAFEBLIT
Xstatic
XSafeClipBlit( src_Wind, src_x, src_y,
X dst_Wind, dst_x, dst_y,
X width, height, min_terms,
X line_no )
X
X struct Window *src_Wind, *dst_Wind;
X LONG src_x, src_y, dst_x, dst_y, width, height, min_terms;
X LONG line_no;
X{
X
X if (src_x < 0 || src_x > src_Wind->Width) {
X printf("Line %d Bad blit src_x %d Width %d\n",
X line_no,src_x,src_Wind->Width);
X return;
X }
X
X if (src_y < 0 || src_y > src_Wind->Height) {
X printf("Line %d Bad blit src_y %d Height %d\n",
X line_no, src_y,src_Wind->Height);
X return;
X }
X
X if (width < 1 || width > src_Wind->Width) {
X printf("Line %d Bad blit width %d\n",line_no, width);
X return;
X }
X
X if (src_x + width > src_Wind->Width) {
X printf("Line %d Blit outside %d Width %d \n",
X line_no,src_x+width,src_Wind->Width);
X return;
X }
X
X if (height < 1 || height > src_Wind->Height) {
X printf("Line %d Bad blit height %d\n",line_no,height);
X return;
X }
X
X if (src_y + height > src_Wind->Height) {
X printf("Line %d Blit outside %d Height %d \n",
X line_no,src_y+height,src_Wind->Height);
X return;
X }
X
X ClipBlit( src_Wind->RPort, src_x, src_y,
X dst_Wind->RPort, dst_x, dst_y,
X width, height, min_terms);
X}
X#endif
X
XScrollComplex(Pict)
X struct Picture *Pict;
X{
X int left, top;
X int count_x, count_y;
X SHORT *NewCounts;
X
X count_x = Pict->Window->Width - Pict->LeftMarg - Pict->RightMarg;
X count_y = Pict->Window->Height - Pict->BotMarg - Pict->TopMarg;
X
X NewCounts = (SHORT *) safeAllocMem(count_x*count_y*sizeof(SHORT),MEMF_CLEAR);
X
X if (NewCounts == NULL) {
X DispErrMsg("Can't scroll. Out of RAM.",0);
X return;
X }
X
X ScrollData(Pict, NewCounts, count_x, count_y);
X
X FreeCounts( Pict );
X
X left = Pict->ImageLoc.Left - Pict->LeftMarg;
X top = Pict->ImageLoc.Top - Pict->TopMarg;
X
X Pict->RealLow -= Pict->RealGap * left;
X Pict->ImagLow -= Pict->ImagGap * top;
X Pict->RealHigh = Pict->RealLow + Pict->RealGap * count_x;
X Pict->ImagHigh = Pict->ImagLow + Pict->ImagGap * count_y;
X
X FreeScrollTemp(Pict);
X
X Pict->Counts = NewCounts;
X Pict->CountX = count_x;
X Pict->CountY = count_y;
X Pict->CountsSize = count_x * count_y * sizeof(*Pict->Counts);
X Pict->CurLine = 0;
X}
X
XScrollData(Pict, NewCounts, width, height)
X register struct Picture *Pict;
X SHORT *NewCounts;
X int width, height;
X{
X int sr,sc;
X register SHORT *s_rowp, *d_rowp, *sp, *dp;
X
X s_rowp = Pict->Counts + Pict->DataClip.Top * Pict->CountX;
X d_rowp = NewCounts + (Pict->ClipImage.Top-Pict->TopMarg) * width;
X
X for (sr = Pict->DataClip.Top; sr < Pict->DataClip.Bot; sr++) {
X
X dp = d_rowp + Pict->ClipImage.Left - Pict->LeftMarg;
X sp = s_rowp + Pict->DataClip.Left;
X
X for (sc = Pict->DataClip.Left; sc < Pict->DataClip.Right; sc++) {
X
X *dp++ = *sp++;
X }
X s_rowp += Pict->CountX;
X d_rowp += width;
X }
X}
X
SHAR_EOF
echo "extracting showhelp.c"
sed 's/^X//' << \SHAR_EOF > showhelp.c
X/*
X * browser - Rummage around on disks.
X *
X * copyright (c) 1986, Mike Meyer
X *
X * Permission is hereby granted to distribute this program, so long as this
X * source file is distributed with it, and this copyright notice is not
X * removed from the file.
X *
X * Hacked up to be used as file displayer within MandelVroom. By Kevin
X * Clague
X */
X
X#include "mandp.h"
X
X#define INTUITION_REV 1L
X#define GRAPHICS_REV 1L
X
X#define LONGEST_NAME 80 /* Longest file name we can deal with */
X#define LONGEST_LINE 256 /* Longest line we will deal with */
X#define AVG_LINE_LENGTH 40 /* A guess, tune it if you need to */
X
X#define UP_GADGET ((unsigned short) 0)
X#define DOWN_GADGET ((unsigned short) 1)
X#define SCROLL_GADGET ((unsigned short) 2)
X#define GWIDTH 16 /* Width of my two gadgets */
X#define GHEIGHT 9 /* and their heights */
X
X#define FIRST 18L
X
X/*
X * Pictures for the up and down arrows
X */
XUSHORT arrows[2][GHEIGHT] = {
X {0xFE7F,
X 0xFC3F,
X 0xF81F,
X 0xF00F, /* Up */
X 0xFE7F,
X 0xFE7F,
X 0xFE7F,
X 0xFE7F,
X 0xFE7F
X },{
X 0xFE7F,
X 0xFE7F,
X 0xFE7F,
X 0xFE7F, /* Down */
X 0xFE7F,
X 0xF00F,
X 0xF81F,
X 0xFC3F,
X 0xFE7F}
X } ;
X
X/*
X * Now, the Image structures that use the arrows
X */
Xstruct Image Arrow_Image[2] = {
X {0, 0, GWIDTH, GHEIGHT, 1, NULL, 1, 0, NULL}, /* Up */
X {0, 0, GWIDTH, GHEIGHT, 1, NULL, 1, 0, NULL} /* Down */
X };
X/*
X * Now, my Gadget structures
X */
Xstatic struct PropInfo prop;
Xstatic struct Image prop_img;
X
Xstatic struct Gadget Scroll_Gadget = {
X /*(struct Gadget *)*/ NULL, /* End of Gadgets */
X 0,10+GHEIGHT, /* Left, Top */
X GWIDTH, -((GHEIGHT*2)+11),
X GRELHEIGHT | GADGHCOMP,
X GADGIMMEDIATE|FOLLOWMOUSE|RELVERIFY, /* Messages when released */
X PROPGADGET,
X (APTR) &prop_img,
X (APTR) NULL, /* No rendering image, using HCOMP */
X /*(struct IntuiText *)*/ NULL,
X 0L, /* No mutex */
X (APTR) &prop,
X HELPSCROLL, /* Yes, this is the scroll gadget */
X (APTR) NULL /* And nothing of mine */
X};
X
Xstatic struct Gadget Up_Gadget = {
X &Scroll_Gadget, /* next gadget is scroll */
X 0,10, /* Left, Top */
X GWIDTH, GHEIGHT,
X GADGIMAGE | GADGHCOMP,
X GADGIMMEDIATE, /* Messages when released */
X BOOLGADGET, /* These be boolean gadgets */
X (APTR) &(Arrow_Image[UP_GADGET]),
X (APTR) NULL, /* No rendering image, using HCOMP */
X /*(struct IntuiText *)*/ NULL,
X 0L, /* No mutex */
X (APTR) NULL, /* Nothing special */
X HELPUP, /* Yes, this is the up gadget */
X (APTR) NULL /* And nothing of mine */
X};
X
Xstatic struct Gadget Down_Gadget = {
X &Up_Gadget, /* Next gadget is Up_Gadget */
X 0, -GHEIGHT, /* Left, Top */
X GWIDTH, GHEIGHT,
X GRELBOTTOM | GADGIMAGE | /* Standard bottom border gadget */
X GADGHCOMP,
X GADGIMMEDIATE | BOTTOMBORDER, /* Messages when released */
X BOOLGADGET, /* These be boolean gadgets */
X (APTR) &(Arrow_Image[DOWN_GADGET]),
X (APTR) NULL, /* No rendering image, using HCOMP */
X /*(struct IntuiText *)*/ NULL,
X 0L, /* No mutex */
X (APTR) NULL, /* Nothing special */
X HELPDOWN, /* Yes, this is the up gadget */
X (APTR) NULL /* And nothing of mine */
X };
X
X/*
X * Now, the window for it all
X */
Xstatic struct NewWindow New_Window = {
X#ifdef DEBUG
X 0, 0, 320, 150, /* smaller window to left printf's show up */
X#else
X 0, 1, 320, 199, /* Full screen */
X#endif
X -1L, -1L, /* Default pens */
X NULL, /* Window closes and gadgets */
X ACTIVATE /* Standard window */
X | SMART_REFRESH | NOCAREREFRESH | SIZEBBOTTOM
X | WINDOWSIZING | WINDOWDEPTH | WINDOWCLOSE | WINDOWDRAG,
X &Down_Gadget, /* Add my gadgets */
X /*(struct Image *)*/ NULL,
X (UBYTE *) "MandelVroom Help Window", /* Title */
X /*(struct Screen *)*/NULL,
X /*(struct BitMap *)*/NULL,
X 100, 40, /* Minimum sizes */
X -1, -1, /* Maximum sizes */
X CUSTOMSCREEN
X } ;
X
X/*
X * My very own variables (mostly for done)
X */
X struct Window *HelpWind = NULL ;
Xstatic FILE *infile = NULL ; /* Current input file */
Xstatic void Page_File();
X char HelpOpen;
X
X/*
X * Finally, declare the string twiddling functions as voids
X */
Xvoid strcat(), strcpy(), strncat();
X
XAllocArrows()
X{
X extern USHORT *MakeChipSprite();
X
X Arrow_Image[0].ImageData = MakeChipSprite( arrows[0], GHEIGHT );
X Arrow_Image[1].ImageData = MakeChipSprite( arrows[1], GHEIGHT );
X}
X
XFreeArrows()
X{
X USHORT *Temp;
X
X Temp = Arrow_Image[0].ImageData;
X
X if (Temp)
X FreeMem( (char *) Temp, (long) sizeof(arrows[0]));
X Arrow_Image[0].ImageData = NULL;
X
X Temp = Arrow_Image[1].ImageData;
X
X if (Temp)
X FreeMem( (char *) Temp, (long) sizeof(arrows[0]));
X Arrow_Image[1].ImageData = NULL;
X}
X
X/*
X * Display_File - given a directory path and file name, put the first page of
X * the file in the window.
X */
X
Xlong aprox_lines, file_size;
Xlong Page_Length = 22L;
X
Xstatic int old_off, new_off;
X
Xstatic
XDisplay_File(dir, name)
Xchar *dir, *name;
X{
X static char File_Name[LONGEST_NAME];
X FILE *fopen();
X long ftell();
X long i;
X
X if (HelpWind == NULL)
X return;
X
X old_off = -1;
X
X /* Get the file name */
X strcpy(File_Name, dir);
X strcat(File_Name, name);
X
X if (infile != NULL)
X fclose(infile);
X
X if ((infile = fopen(File_Name, "r")) == NULL) {
X CloseHelpWind(20, "can't open file") ;
X return;
X }
X
X /* set up the prop gadget for scrolling */
X fseek(infile, 0L, 2);
X file_size = ftell(infile);
X aprox_lines = file_size / AVG_LINE_LENGTH;
X prop.Flags = FREEVERT | AUTOKNOB;
X if (Page_Length >= aprox_lines)
X i = 0xAAAA; /* guess 66% for small files */
X else
X i = (Page_Length * 0x10000) / aprox_lines; /* FFFF=100% - 0000=0% */
X
X prop.VertBody = i;
X prop.VertPot = 0; /* always start at begin of file */
X fseek(infile, 0L, 0);
X
X Page_File(HELPUP); /* Down from page 0 */
X}
X
X/*
X * Page_File - move the file up or down one "page"
X */
Xvoid
XPage_File(direction)
Xint direction;
X{
X register long where;
X static char buffer[LONGEST_LINE];
X static char edited[84]; /* allow room for a tab at end */
X int end_flag = 0;
X long tabs, size, Line_Length;
X int i,j;
X long new_pos;
X char *p;
X
X register struct Window *Window;
X
X Window = HelpWind;
X
X if (infile == NULL) return ;
X
X Page_Length = (Window -> Height - 20) / 8 ;
X Line_Length = (Window -> Width - (3+FIRST)) / 8;
X
X switch (direction) {
X
X case HELPUP: /* Seek back one page */
X if (ftell(infile) < AVG_LINE_LENGTH * (Page_Length + 2))
X fseek(infile, 0L, 0);
X else {
X fseek(infile, (long) -Page_Length * AVG_LINE_LENGTH, 1) ;
X fgets(buffer, LONGEST_LINE, infile) ;
X }
X break;
X
X case HELPDOWN:
X break;
X
X case HELPSCROLL:
X /* compute new position based on the users scroll bar pot */
X new_pos = (file_size * prop.VertPot) / 0x10000;
X
X /* if at end of file, back up 1/2 page */
X if (new_pos >= file_size)
X new_pos = file_size - ((Page_Length / 2) * AVG_LINE_LENGTH);
X fseek(infile, new_pos, 0);
X
X /* discard a partial line */
X if (new_pos)
X fgets(buffer, LONGEST_LINE, infile);
X new_off = ftell(infile);
X
X if (new_off == old_off)
X return;
X
X old_off = new_off;
X break;
X
X default:
X CloseHelpWind(20, "Illegal argument to Page_File");
X return;
X }
X
X SetAPen(Window->RPort, NORMALPEN);
X SetDrMd(Window->RPort, JAM1);
X RectFill(Window->RPort, GWIDTH, 10,
X Window->Width-2, Window->Height-10);
X RectFill(Window->RPort, GWIDTH, Window->Height-10,
X Window->Width-12-(YScale*4),
X Window->Height);
X BorderWindow( Window );
X
X /* now put out one page's worth of the file's data */
X for (where = 17, j = Page_Length; j--; where += 8) {
X
X /* blank the buffer first */
X for (i = 0; i < 80; i++)
X edited[i] = ' ';
X
X if (!end_flag) {
X
X if (fgets(buffer, LONGEST_LINE, infile) == NULL)
X end_flag = TRUE;
X else {
X size = strlen(buffer);
X
X /* remove the newline */
X buffer[size-1] = '\0';
X size--;
X
X p = buffer;
X size = 0;
X
X /* edit the buffer for tabs and non-printables */
X while(*p) {
X
X if (*p == '\t') {
X do {
X edited[size++] = ' ';
X } while(size&3);
X } else
X
X if (*p < ' ') {
X edited[size++] = '^';
X edited[size++] = *p + '@';
X
X } else
X edited[size++] = *p;
X
X p++;
X
X /* mark the line as longer than the window */
X if (size >= Line_Length) {
X edited[size-1] = '>';
X break;
X }
X }
X }
X }
X
X SetAPen(Window->RPort, SHADOWPEN);
X Move(Window -> RPort, FIRST+1, where+1) ;
X Text(Window -> RPort, edited, Line_Length);
X
X SetAPen(Window->RPort, HIGHLIGHTPEN);
X Move(Window -> RPort, FIRST, where) ;
X Text(Window -> RPort, edited, Line_Length);
X
X } /* for 1 to size of window */
X}
X
XShowHelp( DirName, FileName )
X char *DirName, *FileName;
X{
X register struct IntuiMessage *message;
X register unsigned short class, code ;
X
X if (HelpWind == NULL) {
X
X /* set up the scroll bar */
X prop.Flags = FREEVERT | AUTOKNOB;
X prop.VertBody = 0x1000;
X
X New_Window.Screen = screen;
X
X HelpWind = OpenMyWind(&New_Window,screen, NULL, 320, 200);
X
X if (HelpWind == NULL){
X CloseHelpWind(20, "can't open the window") ;
X return;
X }
X
X if (HelpWind == NULL) return;
X
X AddGList( HelpWind, &Down_Gadget, -1, -1);
X
X RefreshGadgets( &Down_Gadget, HelpWind, NULL );
X }
X
X SetAPen(HelpWind->RPort, NORMALPEN);
X SetDrMd(HelpWind->RPort, JAM1);
X RectFill(HelpWind->RPort, GWIDTH, 10,
X HelpWind->Width-2, HelpWind->Height-10);
X RectFill(HelpWind->RPort, GWIDTH, HelpWind->Height-10,
X HelpWind->Width-12-(YScale*4),
X HelpWind->Height);
X BorderWindow( HelpWind );
X
X Display_File(DirName, FileName) ;
X}
X
X/*
X * done - just close everything that's open, and exit.
X */
XCloseHelpWind(how, why)
Xint how;
Xchar *why;
X{
X if (HelpWind) {
X CloseMyWind(HelpWind, NULL) ;
X HelpWind = NULL;
X
X if (infile) {
X fclose(infile) ;
X infile = NULL;
X }
X if (why)
X DispErrMsg(why,0);
X }
X}
X
SHAR_EOF
echo "extracting standard.h"
sed 's/^X//' << \SHAR_EOF > standard.h
X#include <exec/types.h>
X#include <exec/devices.h>
X#include <intuition/intuition.h>
X
X#include <libraries/dos.h>
X#include <libraries/dosextens.h>
X#ifdef MANX
X#include <functions.h>
X#endif
SHAR_EOF
echo "extracting status.c"
sed 's/^X//' << \SHAR_EOF > status.c
X/*
X * MandelVroom 2.0
X *
X * (c) Copyright 1987,1989 Kevin L. Clague, San Jose, CA
X *
X * All rights reserved.
X *
X * Permission is hereby granted to distribute this program's source
X * executable, and documentation for non-comercial purposes, so long as the
X * copyright notices are not removed from the sources, executable or
X * documentation. This program may not be distributed for a profit without
X * the express written consent of the author Kevin L. Clague.
X *
X * This program is not in the public domain.
X *
X * Fred Fish is expressly granted permission to distribute this program's
X * source and executable as part of the "Fred Fish freely redistributable
X * Amiga software library."
X *
X * Permission is expressly granted for this program and it's source to be
X * distributed as part of the Amicus Amiga software disks, and the
X * First Amiga User Group's Hot Mix disks.
X *
X * contents: this file contains functions to open, display and close the
X * statistics window.
X */
X
X#include "mandp.h"
X
Xstruct Window *StatsWind;
X
XUBYTE StatsOpen;
X
Xstatic
Xstruct NewWindow NewStats = {
X 0,200-100, /* start position */
X 90,120, /* width, height */
X (UBYTE) 0, (UBYTE) 1, /* detail pen, block pen */
X NULL, /* IDCMP flags */
X /* MandWind flags */
X WINDOWCLOSE | WINDOWDRAG | WINDOWDEPTH | SMART_REFRESH,
X (struct Gadget *) NULL, /* first gadget */
X (struct Image *) NULL, /* user checkmark */
X (UBYTE *) "Statistics", /* window title */
X (struct Screen *) NULL, /* pointer to screen */
X (struct BitMap *) NULL, /* pointer to superbitmap */
X 80,80,80,80, /* sizing */
X CUSTOMSCREEN /* type of screen */
X};
X
Xstatic
XUBYTE StartString[80], EndString[80], GapString[80], SizeString[80];
Xstatic
XUBYTE MagString[30];
X
Xstatic
Xstruct IntuiText MagIntui = {
X 1, 0, JAM1, 8, 52, NULL,
X (UBYTE *) MagString, NULL
X};
X
Xstatic
Xstruct IntuiText SizeIntui = {
X 1, 0, JAM1, 8, 44, NULL,
X (UBYTE *) SizeString, &MagIntui
X};
X
Xstatic
Xstruct IntuiText GapIntui = {
X 1, 0, JAM1, 8, 36, NULL,
X (UBYTE *) GapString, &SizeIntui
X};
X
Xstatic
Xstruct IntuiText EndIntui = {
X 1, 0, JAM1, 8, 28, NULL,
X (UBYTE *) EndString, &GapIntui
X};
X
Xstatic
Xstruct IntuiText StartIntui = {
X 1, 0, JAM1, 8, 20, NULL,
X (UBYTE *) StartString, &EndIntui
X};
X
Xstatic
Xstruct IntuiText RealIntui = {
X 1, 0, JAM1, 8, 12, NULL,
X (UBYTE *) " Real Imag", &StartIntui
X};
X
X/*
X * Open the statistics window
X */
XOpenStatsWind( Pict )
X struct Picture *Pict;
X{
X struct Window *OpenMyWind();
X
X if (StatsWind == (struct Window *) NULL) {
X
X StatsWind = OpenMyWind( &NewStats, screen, NULL, 320, 80);
X
X } else {
X WindowToFront( StatsWind );
X }
X ShowStats( Pict );
X StatsOpen = 1;
X} /* OpenStatsWind */
X
X/*
X * Close the statistics window
X */
XCloseStatsWind()
X{
X if (StatsWind != (struct Window *) NULL) {
X CloseMyWind( StatsWind, NULL);
X StatsWind = (struct Window *) NULL;
X }
X} /* CloseStatsWind */
X
XShowStats( Pict )
X register struct Picture *Pict;
X{
X register LONG Mag;
X
X if (StatsWind) {
X
X ClearWindow( StatsWind, 0);
X
X Mag = (LONG) 4.0 / (Pict->ImagHigh - Pict->ImagLow);
X
X sprintf( StartString, "Start %15.12f %15.12f", Pict->RealLow, Pict->ImagLow );
X sprintf( EndString, "End %15.12f %15.12f", Pict->RealHigh, Pict->ImagHigh );
X sprintf( GapString, "Gap %15.12f %15.12f", Pict->RealGap, Pict->ImagGap );
X sprintf( SizeString, "Size %15d %15d", Pict->CountX, Pict->CountY );
X sprintf( MagString, "Mag %15d", Mag );
X
X PrintIText( StatsWind->RPort, &RealIntui, 0, 0 );
X }
X}
X
XClearWindow( Window, pen )
X register struct Window *Window;
X int pen;
X{
X register struct RastPort *RPort;
X register LONG bot, right;
X
X RPort = Window->RPort;
X
X SetAPen( RPort, (long) pen);
X
X bot = Window->Height - Window->BorderBottom;
X right = Window->Width - Window->BorderRight;
X
X RectFill( RPort, Window->BorderLeft-1, Window->BorderTop-1, right, bot );
X}
X
X
SHAR_EOF
echo "extracting tasks.c"
sed 's/^X//' << \SHAR_EOF > tasks.c
X/*
X * MandelVroom 2.0
X *
X * (c) Copyright 1987,1989 Kevin L. Clague, San Jose, CA
X *
X * All rights reserved.
X *
X * Permission is hereby granted to distribute this program's source
X * executable, and documentation for non-comercial purposes, so long as the
X * copyright notices are not removed from the sources, executable or
X * documentation. This program may not be distributed for a profit without
X * the express written consent of the author Kevin L. Clague.
X *
X * This program is not in the public domain.
X *
X * Fred Fish is expressly granted permission to distribute this program's
X * source and executable as part of the "Fred Fish freely redistributable
X * Amiga software library."
X *
X * Permission is expressly granted for this program and it's source to be
X * distributed as part of the Amicus Amiga software disks, and the
X * First Amiga User Group's Hot Mix disks.
X *
X * contents: this file contains functions used to manage tasks used by
X * MandelVroom for picture generation and picture recoloring.
X */
X
X#include "mandp.h"
X
XLONG MainPri = 0;
XLONG TaskPri = -1;
X
XLONG pSigMask, pSigBit;
X
XPauseChild( Pict )
X register struct Picture *Pict;
X{
X if (Pict->gTask) {
X
X if (Pict->GenState == GENERATESTATE) {
X
X SetTaskPri( Pict->gTask, MainPri );
X
X Pict->GenState = PAUSESTATE;
X
X Wait( pSigMask );
X
X SetTaskPri( Pict->gTask, TaskPri );
X }
X }
X}
X
XChildSignal( Pict )
X register struct Picture *Pict;
X{
X#ifdef MULTI
X if ( Pict->GenState == PAUSESTATE ) {
X Signal( mTask, pSigMask );
X Wait( Pict->gSigMask );
X }
X#endif
X}
X
XAwakenChild( Pict )
X register struct Picture *Pict;
X{
X if (Pict->gTask) {
X if (Pict->GenState == PAUSESTATE) {
X
X Pict->GenState = GENERATESTATE;
X
X Signal( Pict->gTask, Pict->gSigMask );
X
X if (Pict->gTask->tc_State == TS_WAIT) {
X printf("Child still waiting\n");
X }
X }
X }
X}
X
XCheckEOL( Pict )
X register struct Picture *Pict;
X{
X ChildPause( Pict );
X
X ReColorLine( Pict );
X
X Pict->CurLine++;
X}
X
XKillDoneChild( Pict )
X register struct Picture *Pict;
X{
X if (Pict->gTask) {
X
X SetTaskPri( Pict->gTask, MainPri );
X
X Pict->GenState = KILLSTATE; /* Child is spinning waiting for this */
X Wait( pSigMask ); /* wait till child says it notices this */
X
X DeleteTask(Pict->gTask);
X Pict->gTask = NULL;
X }
X}
X
XGetTaskSig( Pict )
X register struct Picture *Pict;
X{
X register LONG bit;
X
X Pict->gSigBit = bit = AllocSignal( (long) -1 );
X
X if ( bit == -1 )
X return( UNSUCCESSFUL );
X
X Pict->gSigMask = 1 << bit;
X
X return( SUCCESSFUL );
X}
X
Xint
XOpenTasks()
X{
X mTask = FindTask( NULL );
X
X mSigBit = AllocSignal( (long) -1 );
X
X if ( mSigBit == -1 ) {
X return (-1);
X }
X
X mSigMask = 1 << mSigBit;
X
X pSigBit = AllocSignal( (long) -1 );
X
X if ( pSigBit == -1 ) {
X
X FreeSignal( mSigBit );
X return (-1);
X }
X
X pSigMask = 1 << pSigBit;
X
X return( 0 );
X}
X
XCloseTasks()
X{
X FreeSignal( mSigBit );
X FreeSignal( pSigBit );
X}
X
X/* This is called by main task */
X
XThrowTask( Pict )
X register struct Picture *Pict;
X{
X register struct Task *gTask = Pict->gTask;
X
X if (gTask) {
X
X PauseChild( Pict );
X DeleteTask( gTask );
X Pict->gTask = NULL;
X
X SetGenGad( Pict );
X }
X}
X
XCloseZoomedPicts( Pict )
X register struct Picture *Pict;
X{
X register struct Node *zNode;
X register struct Picture *ZoomPict;
X
X struct Picture *PictAddr();
X
X zNode = Pict->zList.lh_Head;
X
X while ( zNode = RemHead( &Pict->zList ) ) {
X
X ZoomPict = PictAddr( zNode );
X
X CloseZoomBox(ZoomPict);
X }
X}
X
X/* Calculate pointer to the beginning of Picture struct */
X
Xstruct Picture *
XPictAddr( zNodeAddr )
X register struct Node *zNodeAddr;
X{
X register char *ZoomPict;
X
X ZoomPict = (char *) zNodeAddr;
X
X ZoomPict -= ((char *) &CurPict->zNode - (char *) &CurPict->pNode);
X
X return( (struct Picture *) ZoomPict );
X}
X
XPauseReColor( Pict )
X register struct Picture *Pict;
X{
X if (Pict->gTask) {
X
X if (Pict->ColorState == GENERATESTATE) {
X
X Pict->ColorState = PAUSESTATE;
X
X (void) Wait( pSigMask );
X }
X }
X}
X
XReColorPause( Pict )
X register struct Picture *Pict;
X{
X if ( Pict->ColorState == PAUSESTATE ) {
X
X Signal( mTask, pSigMask );
X (void) Wait( 0L );
X }
X}
SHAR_EOF
echo "End of archive 9 (of 9)"
# if you want to concatenate archives, remove anything after this line
exit
